<!DOCTYPE html>
<html lang="zh-CN">
<head>
  <meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=2">
<meta name="theme-color" content="#222">
<meta name="generator" content="Hexo 4.2.0">
  <link rel="apple-touch-icon" sizes="180x180" href="/images/apple-touch-icon-next.png">
  <link rel="icon" type="image/png" sizes="32x32" href="/images/ice.png">
  <link rel="icon" type="image/png" sizes="16x16" href="/images/ice.png">
  <link rel="mask-icon" href="/images/logo.svg" color="#222">

<link rel="stylesheet" href="/css/main.css">


<link rel="stylesheet" href="/lib/font-awesome/css/all.min.css">

<script id="hexo-configurations">
    var NexT = window.NexT || {};
    var CONFIG = {"hostname":"yoursite.com","root":"/","scheme":"Gemini","version":"7.8.0","exturl":false,"sidebar":{"position":"left","display":"post","padding":18,"offset":12,"onmobile":false},"copycode":{"enable":true,"show_result":true,"style":null},"back2top":{"enable":true,"sidebar":false,"scrollpercent":false},"bookmark":{"enable":false,"color":"#222","save":"auto"},"fancybox":false,"mediumzoom":false,"lazyload":false,"pangu":false,"comments":{"style":"tabs","active":null,"storage":true,"lazyload":false,"nav":null},"algolia":{"hits":{"per_page":10},"labels":{"input_placeholder":"Search for Posts","hits_empty":"We didn't find any results for the search: ${query}","hits_stats":"${hits} results found in ${time} ms"}},"localsearch":{"enable":true,"trigger":"auto","top_n_per_article":3,"unescape":false,"preload":false},"motion":{"enable":true,"async":false,"transition":{"post_block":"fadeIn","post_header":"slideDownIn","post_body":"slideDownIn","coll_header":"slideLeftIn","sidebar":"slideUpIn"}},"path":"search.xml"};
  </script>

  <meta name="description" content="数据结构数组、链表的优缺点数组的优缺点数组的优点在于：  构建非常简单 能在 O(1) 的时间里根据数组的下标（index）查询某个元素  而数组的缺点在于：  构建时必须分配一段连续的空间 查询某个元素是否存在时需要遍历整个数组，耗费 O(n) 的时间（其中，n 是元素的个数） 删除和添加某个元素时，同样需要耗费 O(n) 的时间">
<meta property="og:type" content="article">
<meta property="og:title" content="数据结构图解">
<meta property="og:url" content="http://yoursite.com/2020/05/30/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E4%B8%8E%E7%AE%97%E6%B3%95/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E5%9B%BE%E8%A7%A3/index.html">
<meta property="og:site_name" content="严冰的博客">
<meta property="og:description" content="数据结构数组、链表的优缺点数组的优缺点数组的优点在于：  构建非常简单 能在 O(1) 的时间里根据数组的下标（index）查询某个元素  而数组的缺点在于：  构建时必须分配一段连续的空间 查询某个元素是否存在时需要遍历整个数组，耗费 O(n) 的时间（其中，n 是元素的个数） 删除和添加某个元素时，同样需要耗费 O(n) 的时间">
<meta property="og:locale" content="zh_CN">
<meta property="og:image" content="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pji7rupg31400m8e82.gif">
<meta property="og:image" content="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pjjm5lsg31400m8x6p.gif">
<meta property="og:image" content="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pjmttggg31hc0p0hdz.gif">
<meta property="og:image" content="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pjqntv9g31hc0p04qz.gif">
<meta property="og:image" content="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pjv2qjkg31hc0p0u17.gif">
<meta property="og:image" content="https://math.jianshu.com/math?formula=%7CV%7C%5E2">
<meta property="og:image" content="https://math.jianshu.com/math?formula=O(%7CV%7C%5E2)">
<meta property="og:image" content="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pkikpvtj30lo07agm5.jpg">
<meta property="og:image" content="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pkjlqq5g31hc0p0npd.gif">
<meta property="og:image" content="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pkm7y06g31hc0p0qv6.gif">
<meta property="og:image" content="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pkpueksg31hc0p01ky.gif">
<meta property="og:image" content="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pkr4of1g31hc0p0b2a.gif">
<meta property="og:image" content="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pksjmsug31hc0p07u8.gif">
<meta property="og:image" content="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pktes4kg31hc0p01kx.gif">
<meta property="og:image" content="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pkvfz1hg31hc0p0b2c.gif">
<meta property="og:image" content="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pkybm5pg31hc0p0u0z.gif">
<meta property="og:image" content="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pl03gzfg31hc0p0e84.gif">
<meta property="og:image" content="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pl2k7m0g31hc0p0x6q.gif">
<meta property="og:image" content="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pl4blmyg31hc0p0npe.gif">
<meta property="og:image" content="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pl5o2dkg31hc0p0kjm.gif">
<meta property="og:image" content="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pl7b5bwg31hc0p0npf.gif">
<meta property="og:image" content="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pl8dhgrj30lo07amxp.jpg">
<meta property="og:image" content="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pl9uwyag31hc0p04qq.gif">
<meta property="og:image" content="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4plcbbsfg31hc0p0b2c.gif">
<meta property="og:image" content="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pletvd7g31hc0p07wn.gif">
<meta property="og:image" content="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4plgfn9qg31hc0p0x6q.gif">
<meta property="og:image" content="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pliczz6g31hc0p0hdv.gif">
<meta property="og:image" content="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pljpkvng31hc0p0e81.gif">
<meta property="og:image" content="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4plm8b90g31hc0p0npe.gif">
<meta property="og:image" content="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4plnm5iog31hc0p07wi.gif">
<meta property="og:image" content="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4plotsqwg31hc0p0u0x.gif">
<meta property="article:published_time" content="2020-05-30T12:50:49.000Z">
<meta property="article:modified_time" content="2020-06-08T00:57:51.991Z">
<meta property="article:author" content="yanbing">
<meta name="twitter:card" content="summary">
<meta name="twitter:image" content="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pji7rupg31400m8e82.gif">

<link rel="canonical" href="http://yoursite.com/2020/05/30/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E4%B8%8E%E7%AE%97%E6%B3%95/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E5%9B%BE%E8%A7%A3/">


<script id="page-configurations">
  // https://hexo.io/docs/variables.html
  CONFIG.page = {
    sidebar: "",
    isHome : false,
    isPost : true,
    lang   : 'zh-CN'
  };
</script>

  <title>数据结构图解 | 严冰的博客</title>
  






  <noscript>
  <style>
  .use-motion .brand,
  .use-motion .menu-item,
  .sidebar-inner,
  .use-motion .post-block,
  .use-motion .pagination,
  .use-motion .comments,
  .use-motion .post-header,
  .use-motion .post-body,
  .use-motion .collection-header { opacity: initial; }

  .use-motion .site-title,
  .use-motion .site-subtitle {
    opacity: initial;
    top: initial;
  }

  .use-motion .logo-line-before i { left: initial; }
  .use-motion .logo-line-after i { right: initial; }
  </style>
</noscript>

<link rel="alternate" href="/atom.xml" title="严冰的博客" type="application/atom+xml">
</head>

<body itemscope itemtype="http://schema.org/WebPage">
  <div class="container use-motion">
    <div class="headband"></div>

    <header class="header" itemscope itemtype="http://schema.org/WPHeader">
      <div class="header-inner"><div class="site-brand-container">
  <div class="site-nav-toggle">
    <div class="toggle" aria-label="切换导航栏">
      <span class="toggle-line toggle-line-first"></span>
      <span class="toggle-line toggle-line-middle"></span>
      <span class="toggle-line toggle-line-last"></span>
    </div>
  </div>

  <div class="site-meta">

    <a href="/" class="brand" rel="start">
      <span class="logo-line-before"><i></i></span>
      <h1 class="site-title">严冰的博客</h1>
      <span class="logo-line-after"><i></i></span>
    </a>
  </div>

  <div class="site-nav-right">
    <div class="toggle popup-trigger">
        <i class="fa fa-search fa-fw fa-lg"></i>
    </div>
  </div>
</div>




<nav class="site-nav">
  <ul id="menu" class="main-menu menu">
        <li class="menu-item menu-item-home">

    <a href="/" rel="section"><i class="fa fa-home fa-fw"></i>首页</a>

  </li>
        <li class="menu-item menu-item-categories">

    <a href="/categories/" rel="section"><i class="fa fa-th fa-fw"></i>分类</a>

  </li>
        <li class="menu-item menu-item-tags">

    <a href="/tags/" rel="section"><i class="fa fa-tags fa-fw"></i>标签</a>

  </li>
        <li class="menu-item menu-item-archives">

    <a href="/archives/" rel="section"><i class="fa fa-archive fa-fw"></i>归档</a>

  </li>
      <li class="menu-item menu-item-search">
        <a role="button" class="popup-trigger"><i class="fa fa-search fa-fw"></i>搜索
        </a>
      </li>
  </ul>
</nav>



  <div class="search-pop-overlay">
    <div class="popup search-popup">
        <div class="search-header">
  <span class="search-icon">
    <i class="fa fa-search"></i>
  </span>
  <div class="search-input-container">
    <input autocomplete="off" autocapitalize="off"
           placeholder="搜索..." spellcheck="false"
           type="search" class="search-input">
  </div>
  <span class="popup-btn-close">
    <i class="fa fa-times-circle"></i>
  </span>
</div>
<div id="search-result">
  <div id="no-result">
    <i class="fa fa-spinner fa-pulse fa-5x fa-fw"></i>
  </div>
</div>

    </div>
  </div>

</div>
    </header>

    
  <div class="back-to-top">
    <i class="fa fa-arrow-up"></i>
    <span>0%</span>
  </div>


    <main class="main">
      <div class="main-inner">
        <div class="content-wrap">
          

          <div class="content post posts-expand">
            

    
  
  
  <article itemscope itemtype="http://schema.org/Article" class="post-block" lang="zh-CN">
    <link itemprop="mainEntityOfPage" href="http://yoursite.com/2020/05/30/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E4%B8%8E%E7%AE%97%E6%B3%95/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E5%9B%BE%E8%A7%A3/">

    <span hidden itemprop="author" itemscope itemtype="http://schema.org/Person">
      <meta itemprop="image" content="/images/dog.jpg">
      <meta itemprop="name" content="yanbing">
      <meta itemprop="description" content="闲看庭前花开落，漫随天外云卷舒。">
    </span>

    <span hidden itemprop="publisher" itemscope itemtype="http://schema.org/Organization">
      <meta itemprop="name" content="严冰的博客">
    </span>
      <header class="post-header">
        <h1 class="post-title" itemprop="name headline">
          数据结构图解
        </h1>

        <div class="post-meta">
            <span class="post-meta-item">
              <span class="post-meta-item-icon">
                <i class="far fa-calendar"></i>
              </span>
              <span class="post-meta-item-text">发表于</span>

              <time title="创建时间：2020-05-30 20:50:49" itemprop="dateCreated datePublished" datetime="2020-05-30T20:50:49+08:00">2020-05-30</time>
            </span>
              <span class="post-meta-item">
                <span class="post-meta-item-icon">
                  <i class="far fa-calendar-check"></i>
                </span>
                <span class="post-meta-item-text">更新于</span>
                <time title="修改时间：2020-06-08 08:57:51" itemprop="dateModified" datetime="2020-06-08T08:57:51+08:00">2020-06-08</time>
              </span>
            <span class="post-meta-item">
              <span class="post-meta-item-icon">
                <i class="far fa-folder"></i>
              </span>
              <span class="post-meta-item-text">分类于</span>
                <span itemprop="about" itemscope itemtype="http://schema.org/Thing">
                  <a href="/categories/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E4%B8%8E%E7%AE%97%E6%B3%95/" itemprop="url" rel="index"><span itemprop="name">数据结构与算法</span></a>
                </span>
            </span>

          

        </div>
      </header>

    
    
    
    <div class="post-body" itemprop="articleBody">

      
        <h2 id="数据结构"><a href="#数据结构" class="headerlink" title="数据结构"></a>数据结构</h2><h3 id="数组、链表的优缺点"><a href="#数组、链表的优缺点" class="headerlink" title="数组、链表的优缺点"></a>数组、链表的优缺点</h3><h4 id="数组的优缺点"><a href="#数组的优缺点" class="headerlink" title="数组的优缺点"></a>数组的优缺点</h4><p>数组的优点在于：</p>
<ul>
<li>构建非常简单</li>
<li>能在 O(1) 的时间里根据数组的下标（index）查询某个元素</li>
</ul>
<p>而数组的缺点在于：</p>
<ul>
<li>构建时必须分配一段连续的空间</li>
<li>查询某个元素是否存在时需要遍历整个数组，耗费 O(n) 的时间（其中，n 是元素的个数）</li>
<li>删除和添加某个元素时，同样需要耗费 O(n) 的时间</li>
</ul>
<a id="more"></a>

<h4 id="链表的优缺点"><a href="#链表的优缺点" class="headerlink" title="链表的优缺点"></a>链表的优缺点</h4><p>链表的优点如下：</p>
<ul>
<li>链表能灵活地分配内存空间；</li>
<li>能在 O(1) 时间内删除或者添加元素，前提是该元素的前一个元素已知，当然也取决于是单链表还是双链表，在双链表中，如果已知该元素的后一个元素，同样可以在 O(1) 时间内删除或者添加该元素。</li>
</ul>
<p>链表的缺点是：</p>
<ul>
<li>不像数组能通过下标迅速读取元素，每次都要从链表头开始一个一个读取；</li>
<li>查询第 k 个元素需要 O(k) 时间。</li>
</ul>
<p><strong>应用场景</strong>：如果要解决的问题里面需要很多快速查询，链表可能并不适合；如果遇到的问题中，数据的元素个数不确定，而且需要经常进行数据的添加和删除，那么链表会比较合适。而如果数据元素大小确定，删除插入的操作并不多，那么数组可能更适合。</p>
<h3 id="栈和队列"><a href="#栈和队列" class="headerlink" title="栈和队列"></a>栈和队列</h3><h4 id="栈"><a href="#栈" class="headerlink" title="栈"></a>栈</h4><p><strong>特点：</strong>栈的最大特点就是<strong>后进先出（LIFO）</strong>。对于栈中的数据来说，所有操作都是在栈的顶部完成的，只可以查看栈顶部的元素，只能够向栈的顶部压⼊数据，也只能从栈的顶部弹出数据。</p>
<p><strong>实现：</strong>利用一个<strong>单链表</strong>来实现栈的数据结构。而且，因为我们都只针对栈顶元素进行操作，所以借用单链表的头就能让所有栈的操作在 O(1) 的时间内完成。</p>
<p><strong>应用场景：</strong>在解决某个问题的时候，只要求关心最近一次的操作，并且在操作完成了之后，需要向前查找到更前一次的操作。如果打算用一个数组外加一个指针来实现相似的效果，那么，一旦数组的长度发生了改变，哪怕只是在最后添加一个新的元素，时间复杂度都不再是 O(1)，而且，空间复杂度也得不到优化。</p>
<h4 id="队列"><a href="#队列" class="headerlink" title="队列"></a>队列</h4><p><strong>特点：</strong>和栈不同，队列的最大特点是<strong>先进先出（FIFO）</strong>，就好像按顺序排队一样。对于队列的数据来说，我们只允许在队尾查看和添加数据，在队头查看和删除数据。</p>
<p><strong>实现：</strong>可以借助<strong>双链表</strong>来实现队列。双链表的头指针允许<strong>在队头查看和删除数据</strong>，而双链表的尾指针允许我们<strong>在队尾查看和添加数据</strong>。</p>
<p><strong>应用场景：</strong>直观来看，当我们需要按照一定的顺序来处理数据，而该数据的数据量在不断地变化的时候，则需要队列来帮助解题。在算法面试题当中，广度优先搜索（Breadth-First Search）是运用队列最多的地方。</p>
<h5 id="双端队列"><a href="#双端队列" class="headerlink" title="双端队列"></a>双端队列</h5><p><strong>特点：</strong>双端队列和普通队列最大的不同在于，它允许我们在队列的头尾两端都能在 O(1) 的时间内进行数据的查看、添加和删除。</p>
<p><strong>实现：</strong>与队列相似，我们可以利用一个<strong>双链表</strong>实现双端队列。</p>
<p><strong>应用场景：</strong>双端队列最常用的地方就是实现一个<strong>长度动态变化的窗口或者连续区间</strong>，而动态窗口这种数据结构在很多题目里都有运用。</p>
<h5 id="优先队列（-Priority-Queue）"><a href="#优先队列（-Priority-Queue）" class="headerlink" title="优先队列（ Priority Queue）"></a>优先队列（ Priority Queue）</h5><p><strong>特点：</strong>能保证每次取出的元素都是队列中优先级别最高的。优先级别可以是<strong>自定义</strong>的，例如，数据的数值越大，优先级越高；或者数据的数值越小，优先级越高。优先级别甚至可以通过各种复杂的计算得到。</p>
<p><strong>应用场景：</strong>从一堆杂乱无章的数据当中按照定的顺序（或者优先级）逐步地筛选出部分乃至全部的数据。</p>
<p><strong>实现：</strong>优先队列的本质是一个二叉堆结构。堆在英文里叫 Binary Heap，它是利用一个数组结构来实现的<strong>完全二叉树</strong>。换句话说，优先队列的本质是一个数组，数组里的每个元素既有可能是其他元素的父节点，也有可能是其他元素的子节点，而且，每个父节点只能有两个子节点，很像一棵二叉树的结构。</p>
<blockquote>
<p>  牢记三个重要的性质：</p>
<ol>
<li>数组里的第一个元素 arrays[0]拥有最高的优先级别</li>
<li>给定一个下标i，那么对于元素array[i]而言:<ul>
<li>它的父节点所对应的元素下标是(i-1)/2</li>
<li>它的左孩子所对应的元素下标是2*i+1</li>
<li>它的右孩子所对应的元素下标是2*i+2</li>
</ul>
</li>
<li>数组里每个元素的优先级别都要高于它两个孩子的优先级别</li>
</ol>
</blockquote>
<p>优先队列最基本的操作有两个</p>
<p><strong>向上筛选</strong></p>
<ol>
<li>当有新的数据加入到优先队列中，新的数据首先被放置在二叉堆的底部。</li>
<li>不断进行向上筛选的操作，即如果发现该数据的优先级别比父节点的优先级别还要高，那么就和父节点的元素相互交换，再接着往上进行比较，直到无法再继续交换为止。</li>
</ol>
<p><img src="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pji7rupg31400m8e82.gif" alt=""></p>
<p><strong>时间复杂度：</strong>由于二叉堆是一棵完全二叉树，并假设堆的大小为k，因此整个过程其实就是沿着树的高度往上爬，所以只需要O(log k)的时间。</p>
<p><strong>向下筛选</strong></p>
<ol>
<li>当堆顶的元素被取出时，要更新堆顶的元素来作为下一次按照优先级顺序被取出的对象，需要将堆底部的元素放置到堆顶，然后不断地对它执行向下筛选的操作。</li>
<li>将该元素和它的两个孩子节点对比优先级，如果优先级最高的是其中一个孩子，就将该元素和那个孩子进行交换，然后反复进行下去，直到无法继续交换为止。</li>
</ol>
<p><img src="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pjjm5lsg31400m8x6p.gif" alt="img"></p>
<p><strong>时间复杂度：</strong>整个过程就是沿着树的高度往下爬，所以时间复杂度也是O(log k）</p>
<p>因此，无论是添加新的数据还是取出堆顶的元素，都需要O(log k)的时间。</p>
<p><strong>初始化</strong></p>
<p>优先队列的初始化是一个<strong>最重要</strong>的时间复杂度，是分析运用优先队列性能时必不可少的，也是经常容易弄错的地方。</p>
<p><strong>误区：</strong>每当把—个数据加入到堆里，都要对其执行向上筛选的操作，这样一来就是O(n log n)。</p>
<p><strong>解法：</strong>在创建这个堆的过程中，二叉树的大小是从1逐渐增长到n的，所以整个算法的复杂度经过推导，最终的结果是O(n)。</p>
<p>注意：算法面试中是不要求推导的，你只需要记住，初始化大小为n的堆，所需要的时间是O（n）即可。</p>
<h3 id="树"><a href="#树" class="headerlink" title="树"></a>树</h3><p>树的结构十分直观，而树的很多概念定义都有一个相同的特点：递归，也就是说，一棵树要满足某种性质，往往要求每个节点都必须满足。例如，在定义一棵二叉搜索树时，每个节点也都必须是一棵二叉搜索树。</p>
<p>正因为树有这样的性质，大部分关于树的面试题都与递归有关，换句话说，面试官希望通过一道关于树的问题来考察对于递归算法掌握的熟练程度。</p>
<h4 id="树的形状"><a href="#树的形状" class="headerlink" title="树的形状"></a>树的形状</h4><p>在面试中常考的树的形状有：普通二叉树、平衡二叉树、完全二叉树、二叉搜索树、四叉树（Quadtree）、多叉树（N-ary Tree）。</p>
<p>对于一些特殊的树，例如红黑树（Red-Black Tree）、自平衡二叉搜索树（AVL Tree），一般在面试中不会被问到，除非你所涉及的研究领域跟它们相关或者你十分感兴趣，否则不需要特别着重准备。</p>
<p>关于树的考题，无非就是要考查<strong>树的遍历</strong>以及<strong>序列化（serialization)</strong>。</p>
<h4 id="树的遍历"><a href="#树的遍历" class="headerlink" title="树的遍历"></a>树的遍历</h4><h5 id="前序遍历（Preorder-Traversal）"><a href="#前序遍历（Preorder-Traversal）" class="headerlink" title="前序遍历（Preorder Traversal）"></a>前序遍历（Preorder Traversal）</h5><p><strong>方法：</strong>先访问根节点，然后访问左子树，最后访问右子树。在访问左、右子树的时候，同样，先访问子树的根节点，再访问子树根节点的左子树和右子树，这是一个不断递归的过程。</p>
<p> <img src="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pjmttggg31hc0p0hdz.gif" alt="img"></p>
<p>​    </p>
<p><strong>应用场景：</strong>运用最多的场合包括在树里进行<strong>搜索</strong>以及<strong>创建一棵新的树</strong>。</p>
<h5 id="中序遍历（Inorder-Traversal）"><a href="#中序遍历（Inorder-Traversal）" class="headerlink" title="中序遍历（Inorder Traversal）"></a>中序遍历（Inorder Traversal）</h5><p><strong>方法：</strong>先访问左子树，然后访问根节点，最后访问右子树，在访问左、右子树的时候，同样，先访问子树的左边，再访问子树的根节点，最后再访问子树的右边。</p>
<p><img src="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pjqntv9g31hc0p04qz.gif" alt="img">      </p>
<p><strong>应用场景：</strong>最常见的是<strong>二叉搜素树</strong>，由于二叉搜索树的性质就是左孩子小于根节点，根节点小于右孩子，对二叉搜索树进行中序遍历的时候，被访问到的节点大小是按顺序进行的。</p>
<h5 id="后序遍历（Postorder-Traversal）"><a href="#后序遍历（Postorder-Traversal）" class="headerlink" title="后序遍历（Postorder Traversal）"></a>后序遍历（Postorder Traversal）</h5><p><strong>方法：</strong>先访问左子树，然后访问右子树，最后访问根节点。</p>
<p><img src="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pjv2qjkg31hc0p0u17.gif" alt="img">       </p>
<p><strong>应用场景：</strong>在对某个节点进行分析的时候，需要来自左子树和右子树的信息。收集信息的操作是从树的底部不断地往上进行，好比你在修剪一棵树的叶子，修剪的方法是从外面不断地往根部将叶子一片片地修剪掉。</p>
<p><strong>注意：</strong></p>
<p>掌握好这三种遍历的<strong>递归写法</strong>和<strong>非递归写法</strong>是非常重要的，懂得分析各种写法的<strong>时间复杂度</strong>和<strong>空间复杂度</strong>同样重要。</p>
<p>无论是前端工程师，还是后端工程师，在准备面试的时候，树这个数据结构都是最应该花时间学习的，既能证明你对递归有很好的认识，又能帮助你学习图论。树的许多性质都是面试的热门考点，尤其是<strong>二叉搜索树（BST）</strong><code>（二叉搜索树的性质：对于每个节点来说，该节点的值比左孩子大，比右孩子小，而且一般来说，二叉搜索树里不出现重复的值）</code>。</p>
<h3 id="图"><a href="#图" class="headerlink" title="图"></a>图</h3><h4 id="基本知识点"><a href="#基本知识点" class="headerlink" title="基本知识点"></a><strong>基本知识点</strong></h4><p>图可以说是所有数据结构里面知识点最丰富的一个，最基本的知识点如下：</p>
<ul>
<li><p>阶、出度、入度</p>
</li>
<li><p>树、森林、环</p>
</li>
<li><p>有向图、无向图、完全有向图、完全无向图</p>
</li>
<li><p>连通图、连通分量</p>
</li>
<li><p>存储和表达方式：邻接矩阵、邻接链表</p>
</li>
</ul>
<p>根据长期的经验总结，以下的知识点是必须充分掌握并反复练习:</p>
<h4 id="基本存储方式"><a href="#基本存储方式" class="headerlink" title="基本存储方式"></a>基本存储方式</h4><h5 id="邻接链表（Adjacency-List）"><a href="#邻接链表（Adjacency-List）" class="headerlink" title="邻接链表（Adjacency List）"></a>邻接链表（Adjacency List）</h5><p><strong>无向图 graph 表示</strong></p>
<p><strong>有向图 digraph 表示</strong></p>
<h5 id="邻接矩阵（-Adjacency-Matrix）"><a href="#邻接矩阵（-Adjacency-Matrix）" class="headerlink" title="邻接矩阵（ Adjacency Matrix）"></a>邻接矩阵（ Adjacency Matrix）</h5><p><strong>无向图 graph 表示</strong></p>
<p><strong>有向图 digraph 表示</strong></p>
<blockquote>
<p>  若采用邻接矩阵表示，则需要申请空间大小为 <img src="https://math.jianshu.com/math?formula=%7CV%7C%5E2" alt="|V|^2"> 的二维数组，在二位数组中保存每两个顶点之间的连通关系，则无论有向图或无向图，邻接矩阵方式的存储<strong>空间复杂度皆为</strong> <img src="https://math.jianshu.com/math?formula=O(%7CV%7C%5E2)" alt="O(|V|^2)">。若只记录图中顶点是否连通，不记录权值大小，则可以使用一个二进制位来表示二维数组的每个元素，并且根据无向图的特点可知，<strong>无向图的邻接矩阵沿对角线对称，所以可以选择记录一半邻接矩阵的形式来节省空间开销</strong>。</p>
</blockquote>
<p><strong>两种存储结构对比</strong></p>
<p>根据邻接表和邻接矩阵的结构特性可知，当图为稀疏图、顶点较多，即图结构比较大时，更适宜选择邻接表作为存储结构。当图为稠密图、顶点较少时，或者不需要记录图中边的权值时，使用邻接矩阵作为存储结构较为合适。</p>
<h4 id="图的遍历"><a href="#图的遍历" class="headerlink" title="图的遍历"></a>图的遍历</h4><h5 id="深度优先搜索（Depth-First-Search-DFS）"><a href="#深度优先搜索（Depth-First-Search-DFS）" class="headerlink" title="深度优先搜索（Depth-First Search / DFS）"></a>深度优先搜索（Depth-First Search / DFS）</h5><p>深度优先搜索，从起点出发，从规定的方向中选择其中一个不断地向前走，直到无法继续为止，然后尝试另外一种方向，直到最后走到终点。就像走迷宫一样，尽量往深处走。</p>
<p><strong>DFS 解决的是连通性的问题，即给定两个点，一个是起始点，一个是终点，判断是不是有一条路径能从起点连接到终点</strong>。起点和终点，也可以指的是某种起始状态和最终的状态。<strong>问题的要求并不在乎路径是长还是短，只在乎有还是没有</strong>。有时候题目也会要求把找到的路径完整的打印出来。</p>
<p><strong>DFS 遍历</strong></p>
<p>对这个图进行深度优先的遍历：</p>
<p><img src="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pkikpvtj30lo07agm5.jpg" alt="img"></p>
<p><strong>解题思路</strong></p>
<p>必须依赖<strong>栈（Stack）</strong>，特点是<strong>后进先出（LIFO）</strong>。</p>
<p>第一步，选择一个起始顶点，例如从顶点 A 开始。把 A 压入栈，标记它为访问过（用红色标记），并输出到结果中。</p>
<p><img src="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pkjlqq5g31hc0p0npd.gif" alt="img"></p>
<p>第二步，寻找<strong>与 A 相连</strong>并且还<strong>没有被访问过</strong>的顶点，顶点 A 与 B、D、G 相连，而且它们都还没有被访问过，我们按照<strong>字母顺序</strong>处理，所以将 B 压入栈，标记它为访问过，并输出到结果中。</p>
<p><img src="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pkm7y06g31hc0p0qv6.gif" alt="img">   </p>
<p>第三步，现在我们在顶点 B 上，重复上面的操作，由于 B 与 A、E、F 相连，如果按照字母顺序处理的话，A 应该是要被访问的，但是 <strong>A 已经被访问</strong>了，所以我们访问顶点 E，将 E 压入栈，标记它为访问过，并输出到结果中。</p>
<p><img src="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pkpueksg31hc0p01ky.gif" alt="img">   </p>
<p>第四步，从 E 开始，E 与 B、G 相连，但是B刚刚被访问过了，所以下一个被访问的将是G，把G压入栈，标记它为访问过，并输出到结果中。</p>
<p><img src="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pkr4of1g31hc0p0b2a.gif" alt="img">   </p>
<p>第五步，现在我们在顶点 G 的位置，由于<strong>与 G 相连的顶点都被访问过</strong>了，类似于我们走到了一个死胡同，必须尝试其他的路口了。所以我们这里要做的就是简单地<strong>将 G 从栈里弹出</strong>，表示我们从 G 这里已经无法继续走下去了，看看能不能从前一个路口找到出路。</p>
<p><img src="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pksjmsug31hc0p07u8.gif" alt="img">   </p>
<blockquote>
<p>  可以看到，每次我们在考虑下一个要被访问的点是什么的时候，如果发现周围的顶点都被访问了，就把当前的顶点弹出。</p>
</blockquote>
<p>第六步，现在栈的顶部记录的是顶点 E，我们来看看与 E 相连的顶点中有没有还没被访问到的，发现它们都被访问了，所以把 E 也弹出去。</p>
<p><img src="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pktes4kg31hc0p01kx.gif" alt="img">   </p>
<p>第七步，当前栈的顶点是 B，看看它周围有没有还没被访问的顶点，有，是顶点 F，于是<strong>把 F 压入栈</strong>，标记它为访问过，并输出到结果中。</p>
<p><img src="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pkvfz1hg31hc0p0b2c.gif" alt="img">   </p>
<p>第八步，当前顶点是 F，与 F 相连并且还未被访问到的点是 C 和 D，按照字母顺序来，下一个被访问的点是 C，将 C 压入栈，标记为访问过，输出到结果中。</p>
<p><img src="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pkybm5pg31hc0p0u0z.gif" alt="img">   </p>
<p>第九步，当前顶点为 C，与 C 相连并尚未被访问到的顶点是 H，将 H 压入栈，标记为访问过，输出到结果中。</p>
<p><img src="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pl03gzfg31hc0p0e84.gif" alt="img">   </p>
<p>第十步，当前顶点是 H，由于和它相连的点都被访问过了，将它弹出栈。</p>
<p><img src="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pl2k7m0g31hc0p0x6q.gif" alt="img">   </p>
<p>第十一步，当前顶点是 C，与 C 相连的点都被访问过了，将 C 弹出栈。</p>
<p><img src="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pl4blmyg31hc0p0npe.gif" alt="img">   </p>
<p>第十二步，当前顶点是 F，与 F 相连的并且尚未访问的点是 D，将 D 压入栈，输出到结果中，并标记为访问过。</p>
<p><img src="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pl5o2dkg31hc0p0kjm.gif" alt="img">   </p>
<p>第十三步，当前顶点是 D，与它相连的点都被访问过了，将它弹出栈。以此类推，顶点 F，B，A 的邻居都被访问过了，将它们<strong>依次弹出栈</strong>就好了。最后，<strong>当栈里已经没有顶点需要处理了，我们的整个遍历结束</strong>。</p>
<p><img src="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pl7b5bwg31hc0p0npf.gif" alt="img">   </p>
<p><strong>算法分析</strong> </p>
<p>DFS 是图论里的算法，分析利用 DFS 解题的复杂度时，应当借用图论的思想。图有两种表示方式：邻接表、邻接矩阵。假设图里有 V 个顶点，E 条边。</p>
<p><strong>时间复杂度：</strong></p>
<ul>
<li><p>邻接表</p>
<p>访问所有顶点的时间为 O(V)，而查找所有顶点的邻居一共需要 O(E) 的时间，所以总的时间复杂度是 <strong>O(V + E)</strong>。</p>
</li>
<li><p>邻接矩阵</p>
<p>查找每个顶点的邻居需要 O(V) 的时间，所以查找整个矩阵的时候需要 <strong>O(V²)</strong> 的时间。</p>
</li>
</ul>
<p><strong>空间复杂度：</strong></p>
<p>DFS 需要<strong>堆栈</strong>来辅助，在最坏情况下，得把所有顶点都压入堆栈里，所以它的空间复杂度是 <strong>O(V)</strong>。</p>
<h5 id="广度优先搜索（Breadth-First-Search-BFS）"><a href="#广度优先搜索（Breadth-First-Search-BFS）" class="headerlink" title="广度优先搜索（Breadth-First Search / BFS）"></a>广度优先搜索（Breadth-First Search / BFS）</h5><p>广度优先搜索，一般用来解决<strong>最短路径</strong>的问题。和深度优先搜索不同，广度优先的搜索是从起始点出发，一层一层地进行，每层当中的点距离起始点的步数都是相同的，当找到了目的地之后就可以立即结束。</p>
<p>广度优先的搜索可以同时从起始点和终点开始进行，称之为<strong>双端 BFS</strong>。这种算法往往可以大大地提高搜索的效率。</p>
<p><strong>BFS 遍历</strong></p>
<p>对这个图进行广度优先的遍历：</p>
<p><img src="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pl8dhgrj30lo07amxp.jpg" alt="img"></p>
<p><strong>解题思路</strong></p>
<p>依赖<strong>队列（Queue）</strong>，<strong>先进先出（FIFO）</strong>。一层一层地把与某个点相连的点放入队列中，处理节点的时候正好按照它们进入队列的顺序进行。</p>
<p>第一步，选择一个起始顶点，让我们从顶点 A 开始。把 A 压入队列，标记它为访问过（用红色标记）。</p>
<p><img src="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pl9uwyag31hc0p04qq.gif" alt="img">   </p>
<p>第二步，从队列的头取出顶点 A，打印输出到结果中，同时将<strong>与它相连</strong>的<strong>尚未被访问过</strong>的点按照<strong>字母大小顺序</strong>压入队列，同时把它们都标记为访问过，防止它们被重复地添加到队列中。</p>
<p><img src="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4plcbbsfg31hc0p0b2c.gif" alt="img">   </p>
<p>第三步，从<strong>队列的头</strong>取出顶点 B，打印输出它，同时将与它相连的尚未被访问过的点（也就是 E 和 F）压入队列，同时把它们都标记为访问过。</p>
<p><img src="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pletvd7g31hc0p07wn.gif" alt="img">   </p>
<p>第四步，继续从队列的头取出顶点 D，打印输出它，此时我们发现，与 D 相连的顶点 A 和 F 都被标记访问过了，所以就不要把它们压入队列里。</p>
<p><img src="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4plgfn9qg31hc0p0x6q.gif" alt="img">   </p>
<p>第五步，接下来，队列的头是顶点 G，打印输出它，同样的，G 周围的点都被标记访问过了。我们不做任何处理。</p>
<p><img src="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pliczz6g31hc0p0hdv.gif" alt="img">   </p>
<p>第六步，队列的头是 E，打印输出它，它周围的点也都被标记为访问过了，我们不做任何处理。</p>
<p><img src="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4pljpkvng31hc0p0e81.gif" alt="img">   </p>
<p>第七步，接下来轮到顶点 F，打印输出它，将 C 压入队列，并标记 C 为访问过。</p>
<p><img src="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4plm8b90g31hc0p0npe.gif" alt="img">   </p>
<p>第八步，将 C 从队列中移出，打印输出它，与它相连的 H 还没被访问到，将 H 压入队列，将它标记为访问过。</p>
<p><img src="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4plnm5iog31hc0p07wi.gif" alt="img">   </p>
<p> 第九步，队列里只剩下 H 了，将它移出，打印输出它，发现它的邻居都被访问过了，不做任何事情。</p>
<p><img src="https://tva1.sinaimg.cn/large/007S8ZIlgy1gf4plotsqwg31hc0p0u0x.gif" alt="img">   </p>
<p>第十步，<strong>队列为空，表示所有的点都被处理完毕了</strong>，程序结束。</p>
<p><strong>算法分析</strong></p>
<p>同样借助图论的分析方法，假设有 V 个顶点，E 条边。</p>
<p><strong>时间复杂度：</strong></p>
<ul>
<li><p>邻接表</p>
<p>每个顶点都需要被访问一次，时间复杂度是 O(V)；相连的顶点（也就是每条边）也都要被访问一次，加起来就是 O(E)。因此整体时间复杂度就是 <strong>O(V+E)</strong>。</p>
</li>
<li><p>邻接矩阵</p>
<p>V 个顶点，每次都要检查每个顶点与其他顶点是否有联系，因此时间复杂度是 <strong>O(V²)</strong>。</p>
</li>
</ul>
<p><strong>空间复杂度：</strong></p>
<p>需要借助一个队列，所有顶点都要进入队列一次，从队列弹出一次。在最坏的情况下，空间复杂度是 <strong>O(V)</strong>。</p>

    </div>

    
    
    
        

<div>
<ul class="post-copyright">
  <li class="post-copyright-author">
    <strong>本文作者： </strong>yanbing
  </li>
  <li class="post-copyright-link">
    <strong>本文链接：</strong>
    <a href="http://yoursite.com/2020/05/30/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E4%B8%8E%E7%AE%97%E6%B3%95/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E5%9B%BE%E8%A7%A3/" title="数据结构图解">http://yoursite.com/2020/05/30/数据结构与算法/数据结构图解/</a>
  </li>
  <li class="post-copyright-license">
    <strong>版权声明： </strong>本博客所有文章除特别声明外，均采用 <a href="https://creativecommons.org/licenses/by-nc-sa/4.0/" rel="noopener" target="_blank"><i class="fab fa-fw fa-creative-commons"></i>BY-NC-SA</a> 许可协议。转载请注明出处！
  </li>
</ul>
</div>


      <footer class="post-footer">

        


        
    <div class="post-nav">
      <div class="post-nav-item">
    <a href="/2020/05/30/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E4%B8%8E%E7%AE%97%E6%B3%95/%E6%9F%A5%E6%89%BE%E7%AE%97%E6%B3%95/" rel="prev" title="查找算法">
      <i class="fa fa-chevron-left"></i> 查找算法
    </a></div>
      <div class="post-nav-item">
    <a href="/2020/05/30/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E4%B8%8E%E7%AE%97%E6%B3%95/%E6%8E%92%E5%BA%8F%E7%AE%97%E6%B3%95/" rel="next" title="排序算法">
      排序算法 <i class="fa fa-chevron-right"></i>
    </a></div>
    </div>
      </footer>
    
  </article>
  
  
  



          </div>
          

<script>
  window.addEventListener('tabs:register', () => {
    let { activeClass } = CONFIG.comments;
    if (CONFIG.comments.storage) {
      activeClass = localStorage.getItem('comments_active') || activeClass;
    }
    if (activeClass) {
      let activeTab = document.querySelector(`a[href="#comment-${activeClass}"]`);
      if (activeTab) {
        activeTab.click();
      }
    }
  });
  if (CONFIG.comments.storage) {
    window.addEventListener('tabs:click', event => {
      if (!event.target.matches('.tabs-comment .tab-content .tab-pane')) return;
      let commentClass = event.target.classList[1];
      localStorage.setItem('comments_active', commentClass);
    });
  }
</script>

        </div>
          
  
  <div class="toggle sidebar-toggle">
    <span class="toggle-line toggle-line-first"></span>
    <span class="toggle-line toggle-line-middle"></span>
    <span class="toggle-line toggle-line-last"></span>
  </div>

  <aside class="sidebar">
    <div class="sidebar-inner">

      <ul class="sidebar-nav motion-element">
        <li class="sidebar-nav-toc">
          文章目录
        </li>
        <li class="sidebar-nav-overview">
          站点概览
        </li>
      </ul>

      <!--noindex-->
      <div class="post-toc-wrap sidebar-panel">
          <div class="post-toc motion-element"><ol class="nav"><li class="nav-item nav-level-2"><a class="nav-link" href="#数据结构"><span class="nav-number">1.</span> <span class="nav-text">数据结构</span></a><ol class="nav-child"><li class="nav-item nav-level-3"><a class="nav-link" href="#数组、链表的优缺点"><span class="nav-number">1.1.</span> <span class="nav-text">数组、链表的优缺点</span></a><ol class="nav-child"><li class="nav-item nav-level-4"><a class="nav-link" href="#数组的优缺点"><span class="nav-number">1.1.1.</span> <span class="nav-text">数组的优缺点</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#链表的优缺点"><span class="nav-number">1.1.2.</span> <span class="nav-text">链表的优缺点</span></a></li></ol></li><li class="nav-item nav-level-3"><a class="nav-link" href="#栈和队列"><span class="nav-number">1.2.</span> <span class="nav-text">栈和队列</span></a><ol class="nav-child"><li class="nav-item nav-level-4"><a class="nav-link" href="#栈"><span class="nav-number">1.2.1.</span> <span class="nav-text">栈</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#队列"><span class="nav-number">1.2.2.</span> <span class="nav-text">队列</span></a><ol class="nav-child"><li class="nav-item nav-level-5"><a class="nav-link" href="#双端队列"><span class="nav-number">1.2.2.1.</span> <span class="nav-text">双端队列</span></a></li><li class="nav-item nav-level-5"><a class="nav-link" href="#优先队列（-Priority-Queue）"><span class="nav-number">1.2.2.2.</span> <span class="nav-text">优先队列（ Priority Queue）</span></a></li></ol></li></ol></li><li class="nav-item nav-level-3"><a class="nav-link" href="#树"><span class="nav-number">1.3.</span> <span class="nav-text">树</span></a><ol class="nav-child"><li class="nav-item nav-level-4"><a class="nav-link" href="#树的形状"><span class="nav-number">1.3.1.</span> <span class="nav-text">树的形状</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#树的遍历"><span class="nav-number">1.3.2.</span> <span class="nav-text">树的遍历</span></a><ol class="nav-child"><li class="nav-item nav-level-5"><a class="nav-link" href="#前序遍历（Preorder-Traversal）"><span class="nav-number">1.3.2.1.</span> <span class="nav-text">前序遍历（Preorder Traversal）</span></a></li><li class="nav-item nav-level-5"><a class="nav-link" href="#中序遍历（Inorder-Traversal）"><span class="nav-number">1.3.2.2.</span> <span class="nav-text">中序遍历（Inorder Traversal）</span></a></li><li class="nav-item nav-level-5"><a class="nav-link" href="#后序遍历（Postorder-Traversal）"><span class="nav-number">1.3.2.3.</span> <span class="nav-text">后序遍历（Postorder Traversal）</span></a></li></ol></li></ol></li><li class="nav-item nav-level-3"><a class="nav-link" href="#图"><span class="nav-number">1.4.</span> <span class="nav-text">图</span></a><ol class="nav-child"><li class="nav-item nav-level-4"><a class="nav-link" href="#基本知识点"><span class="nav-number">1.4.1.</span> <span class="nav-text">基本知识点</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#基本存储方式"><span class="nav-number">1.4.2.</span> <span class="nav-text">基本存储方式</span></a><ol class="nav-child"><li class="nav-item nav-level-5"><a class="nav-link" href="#邻接链表（Adjacency-List）"><span class="nav-number">1.4.2.1.</span> <span class="nav-text">邻接链表（Adjacency List）</span></a></li><li class="nav-item nav-level-5"><a class="nav-link" href="#邻接矩阵（-Adjacency-Matrix）"><span class="nav-number">1.4.2.2.</span> <span class="nav-text">邻接矩阵（ Adjacency Matrix）</span></a></li></ol></li><li class="nav-item nav-level-4"><a class="nav-link" href="#图的遍历"><span class="nav-number">1.4.3.</span> <span class="nav-text">图的遍历</span></a><ol class="nav-child"><li class="nav-item nav-level-5"><a class="nav-link" href="#深度优先搜索（Depth-First-Search-DFS）"><span class="nav-number">1.4.3.1.</span> <span class="nav-text">深度优先搜索（Depth-First Search &#x2F; DFS）</span></a></li><li class="nav-item nav-level-5"><a class="nav-link" href="#广度优先搜索（Breadth-First-Search-BFS）"><span class="nav-number">1.4.3.2.</span> <span class="nav-text">广度优先搜索（Breadth-First Search &#x2F; BFS）</span></a></li></ol></li></ol></li></ol></li></ol></div>
      </div>
      <!--/noindex-->

      <div class="site-overview-wrap sidebar-panel">
        <div class="site-author motion-element" itemprop="author" itemscope itemtype="http://schema.org/Person">
    <img class="site-author-image" itemprop="image" alt="yanbing"
      src="/images/dog.jpg">
  <p class="site-author-name" itemprop="name">yanbing</p>
  <div class="site-description" itemprop="description">闲看庭前花开落，漫随天外云卷舒。</div>
</div>
<div class="site-state-wrap motion-element">
  <nav class="site-state">
      <div class="site-state-item site-state-posts">
          <a href="/archives/">
        
          <span class="site-state-item-count">59</span>
          <span class="site-state-item-name">日志</span>
        </a>
      </div>
      <div class="site-state-item site-state-categories">
            <a href="/categories/">
          
        <span class="site-state-item-count">14</span>
        <span class="site-state-item-name">分类</span></a>
      </div>
      <div class="site-state-item site-state-tags">
            <a href="/tags/">
          
        <span class="site-state-item-count">9</span>
        <span class="site-state-item-name">标签</span></a>
      </div>
  </nav>
</div>
  <div class="links-of-author motion-element">
      <span class="links-of-author-item">
        <a href="https://github.com/yanbingzn" title="GitHub → https:&#x2F;&#x2F;github.com&#x2F;yanbingzn" rel="noopener" target="_blank"><i class="fab fa-github fa-fw"></i>GitHub</a>
      </span>
      <span class="links-of-author-item">
        <a href="https://blog.csdn.net/i_silence" title="CSDN → https:&#x2F;&#x2F;blog.csdn.net&#x2F;i_silence" rel="noopener" target="_blank"><i class="fab fa-codiepie fa-fw"></i>CSDN</a>
      </span>
  </div>
  <div class="cc-license motion-element" itemprop="license">
    <a href="https://creativecommons.org/licenses/by-nc-sa/4.0/" class="cc-opacity" rel="noopener" target="_blank"><img src="/images/cc-by-nc-sa.svg" alt="Creative Commons"></a>
  </div>



      </div>

    </div>
  </aside>
  <div id="sidebar-dimmer"></div>


      </div>
    </main>

    <footer class="footer">
      <div class="footer-inner">
        

        
  <div class="beian"><a href="http://www.beian.miit.gov.cn/" rel="noopener" target="_blank">豫ICP备20019377号 </a>
  </div>

<div class="copyright">
  
  &copy; 
  <span itemprop="copyrightYear">2020</span>
  <span class="with-love">
    <i class="fa fa-heart"></i>
  </span>
  <span class="author" itemprop="copyrightHolder">yanbing</span>
</div>

<span id="busuanzi_container_site_uv">
  本站访问次数：<span class="busuanzi-value" id="busuanzi_value_site_pv"></span>
</span>

        
<div class="busuanzi-count">
  <script async src="https://busuanzi.ibruce.info/busuanzi/2.3/busuanzi.pure.mini.js"></script>
    <span class="post-meta-item" id="busuanzi_container_site_uv" style="display: none;">
      <span class="post-meta-item-icon">
        <i class="fa fa-user"></i>
      </span>
      <span class="site-uv" title="总访客量">
        <span id="busuanzi_value_site_uv"></span>
      </span>
    </span>
</div>








      </div>
    </footer>
  </div>

  
  <script size="300" alpha="0.6" zIndex="-1" src="/lib/canvas-ribbon/canvas-ribbon.js"></script>
  <script src="/lib/anime.min.js"></script>
  <script src="/lib/velocity/velocity.min.js"></script>
  <script src="/lib/velocity/velocity.ui.min.js"></script>

<script src="/js/utils.js"></script>

<script src="/js/motion.js"></script>


<script src="/js/schemes/pisces.js"></script>


<script src="/js/next-boot.js"></script>




  
  <script>
    (function(){
      var canonicalURL, curProtocol;
      //Get the <link> tag
      var x=document.getElementsByTagName("link");
		//Find the last canonical URL
		if(x.length > 0){
			for (i=0;i<x.length;i++){
				if(x[i].rel.toLowerCase() == 'canonical' && x[i].href){
					canonicalURL=x[i].href;
				}
			}
		}
    //Get protocol
	    if (!canonicalURL){
	    	curProtocol = window.location.protocol.split(':')[0];
	    }
	    else{
	    	curProtocol = canonicalURL.split(':')[0];
	    }
      //Get current URL if the canonical URL does not exist
	    if (!canonicalURL) canonicalURL = window.location.href;
	    //Assign script content. Replace current URL with the canonical URL
      !function(){var e=/([http|https]:\/\/[a-zA-Z0-9\_\.]+\.baidu\.com)/gi,r=canonicalURL,t=document.referrer;if(!e.test(r)){var n=(String(curProtocol).toLowerCase() === 'https')?"https://sp0.baidu.com/9_Q4simg2RQJ8t7jm9iCKT-xh_/s.gif":"//api.share.baidu.com/s.gif";t?(n+="?r="+encodeURIComponent(document.referrer),r&&(n+="&l="+r)):r&&(n+="?l="+r);var i=new Image;i.src=n}}(window);})();
  </script>




  
<script src="/js/local-search.js"></script>













  

  


  
  <script type="text/javascript"
color="0,0,188" opacity='0.5' zIndex="-1" count="120" src="//cdn.bootcss.com/canvas-nest.js/1.0.0/canvas-nest.min.js"></script>
  

</body>
</html>
